package com.lingyuan.product.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lingyuan.common.core.domain.R;
import com.lingyuan.common.core.domain.vo.pms.SkuAttrVo;
import com.lingyuan.common.core.domain.vo.wms.WmsWareSkuVO;
import com.lingyuan.common.core.domain.vo.pms.SpuOrderItemVo;
import com.lingyuan.common.core.exception.ServiceException;
import com.lingyuan.product.domain.*;
import com.lingyuan.product.domain.vo.SpuVo;
import com.lingyuan.product.domain.vo.WareSkuStock;
import com.lingyuan.product.fegin.SearchServiceFegin;
import com.lingyuan.product.fegin.WareServiceFegin;
import com.lingyuan.product.mapper.SpuMapper;
import com.lingyuan.product.service.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @ClassName SpuServiceImpl
 * @Description 描述
 * @Author guoxin
 * @Date 2024/9/19 19:04
 */
@Service
public class SpuServiceImpl extends ServiceImpl<SpuMapper,SpuEntity> implements SpuService {
    @Autowired
    private SkuService skuService;
    @Autowired
    private AttrService attrService;
    @Autowired
    private SkuSaleAttrValueService skuSaleAttrValueService;
    @Autowired
    private SkuImageService skuImageService;
    @Autowired
    private CategoryService categoryService;
    @Autowired
    private BrandService brandService;
    @Autowired
    private SearchServiceFegin searchServiceFegin;
    @Autowired
    private SpuDescServcie spuDescServcie;
    @Autowired
    private SpuMapper spuMapper;
    @Autowired
    private SpuImageService spuImageService;
    @Autowired
    private WareServiceFegin wareServiceFegin;

    /**
     * 添加商品
     * @param
     */
    @Override
    @Transactional
    public void addSpuInfo(SpuVo spuVo) {

        //添加 spu基本信息
        SpuEntity spuEntity = spuVo.getSpuEntity();
        if (spuEntity.getSpuName()==null){
            throw new ServiceException("商品名称不能为空");
        }
        this.save(spuEntity);
        SpuEntity sysSpuEntuty = this.getOne(new QueryWrapper<SpuEntity>().lambda().eq(SpuEntity::getId, spuEntity.getId()));
        //添加spu描述信息
        SpuDescEntity spuDescEntity = new SpuDescEntity();
        spuDescEntity.setSpuId(sysSpuEntuty.getId());
        spuDescEntity.setDecript(spuVo.getDescipt());
        spuDescServcie.save(spuDescEntity);
        //添加spu图片信息
        SpuImagesEntity spuImagesEntity = new SpuImagesEntity();
        spuImagesEntity.setSpuId(sysSpuEntuty.getId());
        spuImagesEntity.setImgUrl(spuVo.getImage());
        spuImageService.save(spuImagesEntity);
        //添加spu 商品规格
//        Map<String,String> map = JSON.parseObject(spuVo.getProductAttrValue(), Map.class);
//        List<SpuAttrValueEntity> spuAttrValueEntityList = map.keySet().stream().map(attrKey -> {
//            Long attrId = Long.valueOf(attrKey);
//            String attrName = attrService.getById(attrId).getAttrName();
//            SpuAttrValueEntity spuAttrValueEntity = new SpuAttrValueEntity();
//            spuAttrValueEntity.setAttrId(attrId);
//            spuAttrValueEntity.setAttrName(attrName);
//            spuAttrValueEntity.setAttrValue(map.get(attrKey));
//            spuAttrValueEntity.setAttrSort(0);
//            spuAttrValueEntity.setQuickShow(1);
//            return spuAttrValueEntity;
//        }).collect(Collectors.toList());
//        spuAttrService.saveBatch(spuAttrValueEntityList);
        //添加sku  销售属性
        List<SpuVo.SkuSaleAttrVo> attrVoList = spuVo.getAttrVoList();
        List<AttrEntity> attrEntityList = attrVoList.stream().map(s -> {
            AttrEntity attrEntity = new AttrEntity();
            attrEntity.setAttrName(s.getTitle());
            attrEntity.setCatelogId(sysSpuEntuty.getCatalogId());
            attrEntity.setEnable(1);
            attrEntity.setSearchType(1);
            attrEntity.setAttrType(0);
            List<String> listStr = new ArrayList<>();
            List<SpuVo.AttrVo> attrVosList = s.getAttrVosList();
            attrVosList.forEach(attrVo -> listStr.add(attrVo.getValue()));
            String join = String.join(";", listStr);
            attrEntity.setValueSelect(join);
            return attrEntity;
        }).collect(Collectors.toList());
        attrService.saveBatch(attrEntityList);

        //添加 sku 以及属性
        List<SpuVo.DuoTableData> duoTableData = spuVo.getDuoTableData();
        List<String> stringList = getSkuName(attrEntityList);
        for (int i = 0; i < duoTableData.size(); i++) {
            SkuEntity skuEntity1 = new SkuEntity();
            skuEntity1.setSpuId(sysSpuEntuty.getId());
            skuEntity1.setBrandId(sysSpuEntuty.getBrandId());
            skuEntity1.setCatalogId(sysSpuEntuty.getCatalogId());
            skuEntity1.setSkuName(sysSpuEntuty.getSpuName()+stringList.get(i));
            skuEntity1.setSaleCount(duoTableData.get(i).getStock());
            skuEntity1.setPrice(duoTableData.get(i).getPrice());
            skuEntity1.setSkuDesc(sysSpuEntuty.getSpuDescription());
            skuEntity1.setSkuSubtitle(spuVo.getSkuSubtitle());
            skuEntity1.setSkuTitle(sysSpuEntuty.getSpuName()+stringList.get(i));
            skuService.save(skuEntity1);
            //添加销售属性
            String[] value = stringList.get(i).split(";");
            for (int i1 = 0; i1 < attrEntityList.size(); i1++) {
                SkuSaleAttrValueEntity skuSaleAttrValueEntity = new SkuSaleAttrValueEntity();
                skuSaleAttrValueEntity.setAttrId(attrEntityList.get(i1).getAttrId());
                skuSaleAttrValueEntity.setAttrName(attrEntityList.get(i1).getAttrName());
                skuSaleAttrValueEntity.setAttrValue(value[i1]);
                skuSaleAttrValueEntity.setSkuId(skuEntity1.getSkuId());
                skuSaleAttrValueEntity.setAttrSort(0);
                skuSaleAttrValueService.save(skuSaleAttrValueEntity);
            }
        }
    }
    //从指定attrEntityList 中提取每个属性的值，并生成所有可能的组合
    private List<String> getSkuName(List<AttrEntity> attrEntityList){
        List<String> spuNames = new ArrayList<>();
        //创建一个列表用来存放 每个属性的值列表
        ArrayList< List<String>> values = new ArrayList<>();
        for (AttrEntity attrEntity : attrEntityList) {
            String[] value = attrEntity.getValueSelect().split(";");
            values.add(Arrays.asList(value));
        }
        //使用嵌套循环来生成 所有组合
        int[] ints = new int[values.size()];
        int totalCombinations = 1;
        for (List<String> value : values) {
            totalCombinations *= value.size();
        }
        //遍历所有组合
        for (int i1 = 0; i1 < totalCombinations; i1++) {
           //构建每个组合字符串
            StringBuilder stringBuilder = new StringBuilder("");
            //内层循环遍历每个属性值列表
            for (int i = 0; i < values.size(); i++) {
                List<String> stringList = values.get(i);
                stringBuilder.append(stringList.get(ints[i])).append(";");
                ints[i]++;
                if (ints[i] == stringList.size() ){
                    ints[i] = 0;
                    if (i>0){
                        ints[i-1]++;
                    }
                }
            }
            spuNames.add(stringBuilder.toString().trim());
        }
        //组合以字符串形式存储在一个列表中
        return spuNames;
    }
    /**
     * 修改商品
     */
    @Override
    public void updproduct(SpuVo spuVo) {

    }
    /**
     * 上架商品
     */
    //28 21 30 3 3 3  3 3 3 3
    @Override
    public void groupIng(Long spuId) {
        SpuEntity spuEntity = this.getById(spuId);
        if (null == spuEntity){
            throw new ServiceException("商品不存在");
        }
        if (spuEntity.getPublishStatus().equals(1)){
            throw new ServiceException("商品已上架");
        }
        List<SkuEntity> skuEntityList = skuService.list(new QueryWrapper<SkuEntity>().lambda().eq(SkuEntity::getSpuId, spuId));
        if (skuEntityList.size()<=0){
            throw new ServiceException("该商品没有sku");
        }
        List<SkuAttrVo> skuAttrVos = skuEntityList.stream().map(skuEntity -> {
            SkuAttrVo skuAttrVo = new SkuAttrVo();
            //sku信息 skuId
            skuAttrVo.setSkuId(skuEntity.getSkuId());
            //spuId
            skuAttrVo.setSpuId(skuEntity.getSpuId());
            //sku标题
            skuAttrVo.setSkuTitle(skuEntity.getSkuTitle());
            //价格
            skuAttrVo.setPrice(skuEntity.getPrice());
            //默认图片
            SkuImageEntity skuImageEntity = skuImageService.getOne(new QueryWrapper<SkuImageEntity>().lambda()
                    .eq(SkuImageEntity::getSkuId, skuEntity.getSkuId())
                    .eq(SkuImageEntity::getDefaultImg, 1));
            skuAttrVo.setSkuDefaultImg(skuImageEntity.getImgUrl());
            //分类
            CategoryEntity categoryEntity = categoryService.getById(skuEntity.getCatalogId());
            skuAttrVo.setCatalogId(categoryEntity.getCatId());
            skuAttrVo.setCatalogName(categoryEntity.getName());
            //品牌
            BrandEntity brandEntity = brandService.getById(skuEntity.getBrandId());
            skuAttrVo.setBrandId(brandEntity.getBrandId());
            skuAttrVo.setBrandName(brandEntity.getName());
            skuAttrVo.setBrandImg(brandEntity.getLogo());
            //sku属性
            List<SkuSaleAttrValueEntity> skuSaleAttrValueEntityList = skuSaleAttrValueService.list(new QueryWrapper<SkuSaleAttrValueEntity>().lambda()
                    .eq(SkuSaleAttrValueEntity::getSkuId, skuEntity.getSkuId()));
            List<SkuAttrVo.attrVo> collect = skuSaleAttrValueEntityList.stream().map(s -> {
                SkuAttrVo.attrVo attrVo = new SkuAttrVo.attrVo();
                //拷贝
                BeanUtils.copyProperties(s, attrVo);
                return attrVo;
            }).collect(Collectors.toList());
            skuAttrVo.setAttrVoList(collect);
            return skuAttrVo;
        }).collect(Collectors.toList());
        R r = searchServiceFegin.bulkAdd(skuAttrVos);
        if (r.getCode()!=200){
            throw new ServiceException("商品上架失败");
        }
        //上架成功修改状态
        SpuEntity spuEntity1 = new SpuEntity();
        spuEntity1.setId(spuId);
        spuEntity1.setPublishStatus(1);
        spuEntity1.setUpdateTime(new Date());
        this.updateById(spuEntity1);
    }

    @Override
    public void deleteSpuId(Long spuId) {
        if (null == spuId){
            throw new ServiceException("参数错误");
        }
        SpuEntity spuEntity1 = new SpuEntity();
        spuEntity1.setId(spuId);
        spuEntity1.setPublishStatus(0);
        spuEntity1.setUpdateTime(new Date());
        this.updateById(spuEntity1);
        searchServiceFegin.del(spuId);
    }
    /**
     * 设置库存
     */
    @Override
    public void addStock(WareSkuStock wareSkuStock) {
        SkuEntity skuEntity = skuService.getById(wareSkuStock.getSkuId());
        //添加商品库存信息
        WmsWareSkuVO wmsWareSkuVO = new WmsWareSkuVO();
        wmsWareSkuVO.setSkuId(wareSkuStock.getSkuId());
        wmsWareSkuVO.setUserId(1L);
        wmsWareSkuVO.setStock(wareSkuStock.getStock());
        wmsWareSkuVO.setSkuName(skuEntity.getSkuName());
        wmsWareSkuVO.setStockLocked(0);
        wmsWareSkuVO.setWarning(100);
        wareServiceFegin.addSkuWare(wmsWareSkuVO);
    }

    @Override
    public SpuOrderItemVo findBySkuIdSpuInfo(Long skuId) {
        SpuOrderItemVo spuOrderItemVo = spuMapper.findBySkuIdSpuInfo(skuId);
        if (spuOrderItemVo == null){
            throw new ServiceException("商品不存在");
        }
        return spuOrderItemVo;
    }
}
